import java.util.*;

/**
 * 非递归方式（栈）计算前缀表达式的值
 * 前缀表达式示例：* 5 + 3 4  应输出35.00
 */
public class A2 {
    
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        
        System.err.println("请输入前缀表达式（例如: * 5 + 3 4）：");
        String input = scanner.nextLine();
        
        try {
            double result = evaluatePrefixExpression(input);
            System.out.printf("%.2f\n", result);
        } catch (Exception e) {
            System.err.println("错误：" + e.getMessage());
        }
        
        scanner.close();
    }
    
    /**
     * 非递归方式计算前缀表达式
     * 思路：从右到左扫描，使用栈存储操作数
     */
    public static double evaluatePrefixExpression(String expression) {
        // 将表达式按空格分割成token
        String[] tokens = expression.trim().split("\\s+");
        
        // 检查表达式是否为空
        if (tokens.length == 0 || (tokens.length == 1 && tokens[0].isEmpty())) {
            throw new IllegalArgumentException("表达式不能为空");
        }
        
        // 使用栈存储操作数
        Stack<Double> stack = new Stack<>();
        
        // 从右到左扫描表达式
        for (int i = tokens.length - 1; i >= 0; i--) {
            String token = tokens[i];
            
            // 如果是操作符
            if (isOperator(token)) {
                // 确保栈中有至少两个操作数
                if (stack.size() < 2) {
                    throw new IllegalArgumentException("表达式格式错误：缺少操作数");
                }
                
                // 弹出两个操作数（注意顺序：栈顶是第一个操作数）
                double operand1 = stack.pop();
                double operand2 = stack.pop();
                
                // 执行运算并将结果入栈
                double result = performOperation(token, operand1, operand2);
                stack.push(result);
            } else {
                // 如果是操作数，转换为double并入栈
                try {
                    double value = Double.parseDouble(token);
                    stack.push(value);
                } catch (NumberFormatException e) {
                    throw new IllegalArgumentException("无效的数字格式: " + token);
                }
            }
        }
        
        // 最终栈中应该只剩下一个元素，即表达式的计算结果
        if (stack.size() != 1) {
            throw new IllegalArgumentException("表达式格式错误：操作符数量不正确");
        }
        
        return stack.pop();
    }
    
    /**
     * 判断字符串是否为操作符
     */
    private static boolean isOperator(String token) {
        return token.equals("+") || token.equals("-") || 
               token.equals("*") || token.equals("/");
    }
    
    /**
     * 执行四则运算
     */
    private static double performOperation(String operator, double operand1, double operand2) {
        switch (operator) {
            case "+":
                return operand1 + operand2;
            case "-":
                return operand1 - operand2;
            case "*":
                return operand1 * operand2;
            case "/":
                if (operand2 == 0) {
                    throw new ArithmeticException("除数不能为零");
                }
                return operand1 / operand2;
            default:
                throw new IllegalArgumentException("不支持的操作符: " + operator);
        }
    }
}
